View Javadoc
   /************************************************************
   *                     Copyright                            *
   * Portions of this software are Copyright (c) 1993 - 2002, *
   * Chad Z. Hower (Kudzu) and the Indy Pit Crew              *
   *  - http://www.nevrona.com/Indy/                          *
   ************************************************************/
   
   /************************************************************
   *                     Copyright                            *
  * Portions of this software are Copyright (c) 1993 - 2002, *
  * Chad Z. Hower (Kudzu) and the Indy Pit Crew              *
  *  - http://www.nevrona.com/Indy/                          *
  ************************************************************/
  package org.indy;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Iterator;
  
  
  /***
   *  Provides the basis for Indy threading as used by {@link PeerThread} in {@link TCPServer}.
   *
   *
   *@author    OTG
   *@version  1.0
   *@see StopMode
   *@see Priority
   */
  public abstract class IndyThread implements Runnable {
    /***
     *
     */
    private Priority priority = Priority.NORMAL;
  
    /***
     *
     */
    private StopMode stopMode = StopMode.TERMINATE;
  
    /***
     *
     */
    private volatile Exception terminatingException;
  
    /***
     *
     */
    private volatile boolean stopped = true;
  
    /***
     *
     */
    private volatile boolean terminated = false;
  
    /***
     *
     */
    private final Object suspendLock = new Object();
  
    /***
     *
     */
    protected final Thread threadImpl = new IndyThreadImpl();
  
    /***
     *
     */
    private final ArrayList threadListeners = new ArrayList();
  
    /***
     *  Description of the Field
     */
    protected volatile boolean stopRequested;
  
    /***
     *  Constructor for the IdThread object
     */
    public IndyThread() {
    }
  
    /***
     *  Gets the stopped attribute of the IdThread object
     *
     *@return    The stopped value
     */
    public boolean isStopped() {
      return stopped;
    }
  
    /***
     *
     * @return
     */
    protected Thread getThreadImpl() {
      return threadImpl;
    }
  
   /***
    *  Description of the Method
    */
   public final void start() {
     if (terminated) {
       throw new IllegalStateException();
     }
 
     if (!threadImpl.isAlive()) {
       threadImpl.start();
     }
     else if (stopped) {
       resume();
     }
 
     stopped = false;
   }
 
   /***
    *  Description of the Method
    */
   public final void stop() {
     if (!stopped) {
       if (stopMode == StopMode.TERMINATE) {
         terminate();
       }
 
       stopped = true;
     }
   }
 
   /***
    *
    */
   public void terminate() {
     stopped = true;
     terminated = true;
     resume();
   }
 
   /***
    *
    */
   private void resume() {
     synchronized (suspendLock) {
       suspendLock.notifyAll();
     }
   }
 
   /***
    *
    * @throws InterruptedException
    */
   private void suspend() throws InterruptedException {
     synchronized (suspendLock) {
       suspendLock.wait();
     }
   }
 
   /***
    *  Description of the Method
    *
    *@throws  InterruptedException  Description of the Exception
    */
   public void join() throws InterruptedException {
     threadImpl.join();
   }
 
   /***
    *  Description of the Method
    *
    *@throws  InterruptedException  Description of the Exception
    */
   public void terminateAndWait() throws InterruptedException {
     terminate();
     join();
   }
 
   /***
    *
    * @return
    */
   public StopMode getStopMode() {
     return stopMode;
   }
 
   /***
    *
    * @param mode
    */
   public void setStopMode(StopMode mode) {
     stopMode = mode;
   }
 
   /***
    *
    * @return
    */
   public Priority getPriority() {
     //return priority;
     return Priority.parse(threadImpl.getPriority());
   }
 
   /***
    *
    * @param p
    */
   public void setPriority(Priority p) {
     priority = p;
 
     if (!terminated) {
       threadImpl.setPriority(p.num);
     }
   }
 
   /***
    *
    */
   protected void cleanup() throws InterruptedException {
   }
 
   /***
    *  Description of the Method
    */
   protected void beforeRun() throws InterruptedException {
   }
 
   /***
    *  Description of the Method
    */
   protected void afterRun() throws InterruptedException {
   }
 
   /***
    *  Description of the Method
    */
   protected void beforeExecute() throws InterruptedException {
   }
 
   /***
    *  Description of the Method
    */
   protected void afterExecute() throws InterruptedException {
   }
 
   /***
    *  Adds a feature to the ThreadListener attribute of the IdThread object
    *
    *@param  l  The feature to be added to the ThreadListener attribute
    */
   public void addThreadListener(IndyThreadListener l) {
     synchronized (threadListeners) {
       if (!threadListeners.contains(l)) {
         threadListeners.add(l);
       }
     }
   }
 
   /***
    *
    * @param l
    */
   public void removeThreadListener(IndyThreadListener l) {
     threadListeners.remove(l);
   }
 
   /***
    *
    */
   private void doStopped() {
     Collection l = null;
 
     //don't want to block the list for the entire iteration (which could take any amount of time)
     synchronized (threadListeners) {
       l = Collections.unmodifiableCollection(threadListeners);
     }
 
     IndyThreadEvent evt = new IndyThreadEvent(this);
 
     Iterator i = l.iterator();
 
     while (i.hasNext()) {
       ((IndyThreadListener) i.next()).onStopped(evt);
     }
   }
 
   /***
    *
    */
   private void doException() {
     Collection l = null;
 
     //don't want to block the list for the entire iteration (which could take any amount of time)
     synchronized (threadListeners) {
       l = Collections.unmodifiableCollection(threadListeners);
     }
 
     IndyThreadEvent evt = new IndyThreadEvent(this);
 
     Iterator i = l.iterator();
 
     while (i.hasNext()) {
       ((IndyThreadListener) i.next()).onException(evt);
     }
   }
 
   /***
    * An enumertaed class describing the possible stopping modes for an IndyThread.
    *
    * <code>TERMINATE</code> means that any call to stop will terminate the thread, and the IndyThread instance will be unuseable.
    * <code>SUSPEND</code> means that the thread will pause and can be restarted.
    *
    * @author OTG
    * @version 1.0
    * @see IndyThread
    */
   public static class StopMode {
     /***
      * Used to signal that the enclosing <code>IndyThread</code> should terminate when stop is called.
      *
      * @see IndyThread#stop()
      */
     public static final StopMode TERMINATE = new StopMode("Terminate");
 
     /***
      * Used to signal that the enclosing <code>IndyThread</code> should suspend when stop is called.
      *
      * @see IndyThread#stop()
      */
     public static final StopMode SUSPEND = new StopMode("Suspend");
 
     /***
      * A string representation of this <code>StopMode</code>
      */
     private final String friendlyName;
 
     /***
      * Constructs a new <code>StopMode</code>; private to prevent inheritence.
      *
      * @param friendlyName The string representation of this <code>StopMode</code>
      */
     private StopMode(String friendlyName) {
       this.friendlyName = friendlyName;
     }
 
     /***
      * Returns a string representation of this <code>StopMode</code> as a friendly name.
      *
      * @return A user friendly string for this <code>StopMode</code>
      */
     public String toString() {
       return friendlyName;
     }
   }
 
   /***
    * Represents IndyThread priority.
    *
    *
    */
   public static class Priority {
     /***
      *
      */
     public static final Priority MIN = new Priority(Thread.MIN_PRIORITY);
 
     /***
      *
      */
     public static final Priority NORMAL = new Priority(Thread.NORM_PRIORITY);
 
     /***
      *
      */
     public static final Priority MAX = new Priority(Thread.MAX_PRIORITY);
 
     /***
      *
      */
     private final int num;
 
     /***
      *
      * @param num
      */
     private Priority(int num) {
       this.num = num;
     }
 
     public static Priority parse(int value) {
       System.err.println(value);
 
       switch (value) {
         case 1:
         case 2:
         case 3:
           return MIN;
 
         case 4:
         case 5:
         case 6:
           return NORMAL;
 
         case 7:
         case 8:
         case 9:
         case 10:
           return MAX;
 
         default:
           throw new IllegalArgumentException(
               "Not a valid thread priority value (1..10)");
       }
     }
   }
 
   /***
    *
    * <p>Title: </p>
    * <p>Description: </p>
    * <p>Copyright: Copyright (c) 2002</p>
    * <p>Company: </p>
    * @author unascribed
    * @version 1.0
    */
   private class IndyThreadImpl extends Thread {
     public void run() {
       try {
         try {
           beforeExecute();
 
           while (!terminated) {
             if (stopped) {
               doStopped();
 
               if (stopped) {
                 if (terminated) {
                   break;
                 }
 
                 IndyThread.this.suspend();
 
                 if (terminated) {
                   break;
                 }
               }
 
               //if stopped inner
             }
 
             //if stopped outer
             try {
               beforeRun();
 
               try {
                 while (!stopped) {
                   IndyThread.this.run();
                 }
               }
                finally {
                 afterRun();
               }
             }
              finally {
               cleanup();
             }
           }
 
           //while !terminated
         }
 
         //tryf
          finally {
           afterExecute();
         }
       }
 
       //tryc
        catch (Exception e) {
         terminatingException = e;
         doException();
         terminate();
       }
     }
   }
 
   //inner class
 }